import pygame
from OpenGL.GL import *
# from OpenGL.GLU import *
from constantes import *
from gutil import *

## Esto genera texturas y renders estaticos.
## Se compilan una vez y despues no se pueden cambiar.

class Image:
    ## transforma un surface de pygame
    ## en una forma geometrica con textura en opengl

    def __init__(self, sprite):
        self.texture, self.width, self.height = loadImage(sprite)
        self.displayList = createTexDL(self.texture, self.width, self.height)

    def __del__(self):
        if self.texture != None:
            delTexture(self.texture)
            self.texture = None
        if self.displayList != None:
            delDL(self.displayList)
            self.displayList = None

    def draw(self, pos=None, width = None, height = None, color=(1.0,1.0,1.0), rotation=0, rotationCenter=None):
        glColor3fv(color)

        if pos:
            glLoadIdentity()
            glTranslate(pos[0],pos[1],0)

        if rotation != 0:
            if rotationCenter == None:
                rotationCenter = (self.width / 2, self.height / 2)
            (w,h) = rotationCenter
            glTranslate(rotationCenter[0],rotationCenter[1],0)
            glRotate(rotation,0,0,-1)
            glTranslate(-rotationCenter[0],-rotationCenter[1],0)

        if width or height:
            if not width:
                width = self.width
            elif not height:
                height = self.height
            glScalef(width/(self.width*1.0), height/(self.height*1.0), 1.0)

        glCallList(self.displayList)


class Text(Image):
    ## LOS Text's DEBEN SER GENERADOS (SI CAMBIARON) EN EL MOMENTO DE DIBUJARLOS - NO ANTES !!        

    def __init__(self, text, fontsize = 24, color = (0,0,0,0), antialias = 1):
        texttexture = loadText(text, fontsize, color, antialias)
        self.texture = texttexture[0]
        self.width = texttexture[1]
        self.height = texttexture[2]
        self.texture_width = texttexture[3]
        self.texture_height = texttexture[4]
        self.displayList = createTexDL(self.texture, self.texture_width, self.texture_height)
        
        
class TextBox:
    
    MAX = 30
    LARGO = 350
    ANCHO = 30

    def __init__(self, texto="127.0.0.1"):#pixelwar.servegame.com"):
        self.texto = texto
        self.pos_cursor = len(texto)        
        self.cambio = True
        self.txt_ent = None
        
    def update(self):
        texto_ant = self.texto
        cursr_ant = self.pos_cursor
        for e in pygame.event.get():
            if e.type == pygame.KEYDOWN:
                # borrar
                if e.key == pygame.K_BACKSPACE:
                    if self.pos_cursor == 0:
                        continue
                    self.texto = self.texto[:self.pos_cursor-1] + self.texto[self.pos_cursor:]
                    self.pos_cursor -= 1
                    if self.pos_cursor < 0:
                        self.pos_cursor = 0
                # borrar con supr
                elif e.key == pygame.K_DELETE:
                    self.texto = self.texto[:self.pos_cursor] + self.texto[self.pos_cursor+1:]
                # movemos <--
                elif e.key == pygame.K_LEFT:
                    self.pos_cursor -= 1
                    if self.pos_cursor < 0:
                        self.pos_cursor = 0
                # movemos -->
                elif e.key == pygame.K_RIGHT:
                    self.pos_cursor += 1
                    if self.pos_cursor > len(self.texto):
                        self.pos_cursor = len(self.texto)
                # inicio
                elif e.key == pygame.K_HOME:
                    self.pos_cursor = 0
                # fin
                elif e.key == pygame.K_END:
                    self.pos_cursor = len(self.texto)
                # tab
                elif e.key == pygame.K_TAB:
                    # para elegir equipo
                    continue
                ## REFACTORIZAR ESTO
                # escribir letras y numeros
                elif e.key >= 32 and e.key <= 126:
                    if self.pos_cursor < self.MAX:
                        self.texto = self.texto[:self.pos_cursor] +  e.unicode + self.texto[self.pos_cursor:]
                        self.pos_cursor += 1
                # pad numerico
                elif e.key >= 256 and e.key <= 265:
                    if self.pos_cursor < self.MAX:
                        self.texto = self.texto[:self.pos_cursor] +  str(e.key - 256) + self.texto[self.pos_cursor:]
                        self.pos_cursor += 1
                elif e.key == 266:
                    if self.pos_cursor < self.MAX:
                        self.texto = self.texto[:self.pos_cursor] +  "." + self.texto[self.pos_cursor:]
                        self.pos_cursor += 1
                else:
                    pass
                    
        if (texto_ant != self.texto) or (cursr_ant != self.pos_cursor):
            self.cambio = True

    def estaLleno(self):
        return self.pos_cursor == self.MAX
                    
    def limpiar(self):
        self.texto = ""
        self.pos_cursor = 0
        
    def tieneTexto(self):
        return len(self.texto) > 0
        
    def get(self):
        return self.texto
        
    def dibujar(self):
    
        if self.cambio:
            glClearColor(0.0, 0.0, 0.0, 1.0)
            glClear(GL_COLOR_BUFFER_BIT)

        x = (P_X - self.LARGO)/2
        # dibuja el rectangulo
        glLoadIdentity()
        glTranslate(x, 200, 0)
        glBegin(GL_POLYGON)
        glColor3f(1.0, 1.0, 1.0)
        glVertex2i(0, 0)
        glVertex2i(0, -self.ANCHO)
        glVertex2i(self.LARGO, -self.ANCHO)
        glVertex2i(self.LARGO, 0)
        glEnd()
        print "box:", glGetFloatv(GL_CURRENT_COLOR)

        # dibuja el texto
        if self.cambio:            
            txt = self.texto[:self.pos_cursor] + "|" + self.texto[self.pos_cursor:]
            if self.estaLleno():
                color_txt = (255, 0, 0)
            else:
                color_txt = (0, 0, 0)
            self.txt_ent = Text(txt, color=color_txt)
            self.cambio = False
        if self.txt_ent:            
            self.txt_ent.draw(pos=(x+5, 170))
        #else:
        #    self.txt_ent = Text(self.texto)
        
        
class Boton:

    LARGO = 100
    ANCHO = 30
    
    def __init__(self, texto, color, x, y):
        self.texto = texto
        self.color = color
        self.color_txt = (0, 0, 0)
        self.x = x
        self.y = y
        
    def dibujar(self):
        # dibuja el rectangulo
        glLoadIdentity()
        glTranslate(self.x, self.y, 0)
        glBegin(GL_POLYGON)
        glColor3f((float(self.color[0])/255, float(self.color[1])/255, float(self.color[2])/255))
        glVertex2i(0, 0)
        glVertex2i(0, -self.ANCHO)
        glVertex2i(self.LARGO, -self.ANCHO)
        glVertex2i(self.LARGO, 0)
        glEnd()
        # print "boton:", glGetFloatv(GL_CURRENT_COLOR)
        #pygl2d.draw.rect(pygame.Rect(self.x, self.y, self.LARGO, self.ANCHO), self.color)
        #srf_txt = pygl2d.font.RenderText(self.texto, self.color_txt, self.fuente.fuente)
        #srf_txt.draw([self.x + ((self.LARGO - srf_txt.get_width ())/2),
        #              self.y + ((self.ANCHO - srf_txt.get_height())/2)])
        # dibuja el texto
        
        
    def update(self):
        x, y = pygame.mouse.get_pos()
        if (x >= self.x) and (x <= self.x + self.LARGO) and (y >= self.y) and (y <= self.y + self.ANCHO):
            self.color_txt = (255, 255, 255)
            clicks = pygame.mouse.get_pressed()
            if clicks[0]:
                return True
        else:
            self.color_txt = (0, 0, 0)        
        return False